// $ANTLR 3.4 C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g 2012-10-24 19:30:21

    package practica6;


import org.antlr.runtime.*;
import java.util.Stack;
import java.util.List;
import java.util.ArrayList;

@SuppressWarnings({"all", "warnings", "unchecked"})
public class AnalexCParser extends Parser {
    public static final String[] tokenNames = new String[] {
        "<invalid>", "<EOR>", "<DOWN>", "<UP>", "AND", "BLANCO", "BREAK", "CADENA", "CAMBIO_SIGNO", "CHAR", "COMA", "COMILLA", "COMILLAS", "COMPARADOR", "CORCHETES", "CORCHETE_A", "CORCHETE_C", "DECREMENTO", "DIGITO", "DOS_PUNTOS", "FLOAT", "FOR", "IDENT", "IF", "IGUAL", "INCREMENTO", "INT", "INTERROGANTE", "LETRA", "LLAVE_A", "LLAVE_C", "MAIN", "NOT", "NUMERO", "OPERADOR", "OR", "PARENTESIS_A", "PARENTESIS_C", "PRINTF", "PUNTO_COMA", "VOID", "WHILE", "ASTERISCO"
    };

    public static final int EOF=-1;
    public static final int AND=4;
    public static final int BLANCO=5;
    public static final int BREAK=6;
    public static final int CADENA=7;
    public static final int CAMBIO_SIGNO=8;
    public static final int CHAR=9;
    public static final int COMA=10;
    public static final int COMILLA=11;
    public static final int COMILLAS=12;
    public static final int COMPARADOR=13;
    public static final int CORCHETES=14;
    public static final int CORCHETE_A=15;
    public static final int CORCHETE_C=16;
    public static final int DECREMENTO=17;
    public static final int DIGITO=18;
    public static final int DOS_PUNTOS=19;
    public static final int FLOAT=20;
    public static final int FOR=21;
    public static final int IDENT=22;
    public static final int IF=23;
    public static final int IGUAL=24;
    public static final int INCREMENTO=25;
    public static final int INT=26;
    public static final int INTERROGANTE=27;
    public static final int LETRA=28;
    public static final int LLAVE_A=29;
    public static final int LLAVE_C=30;
    public static final int MAIN=31;
    public static final int NOT=32;
    public static final int NUMERO=33;
    public static final int OPERADOR=34;
    public static final int OR=35;
    public static final int PARENTESIS_A=36;
    public static final int PARENTESIS_C=37;
    public static final int PRINTF=38;
    public static final int PUNTO_COMA=39;
    public static final int VOID=40;
    public static final int WHILE=41;
    public static final int ASTERISCO=42;

    // delegates
    public Parser[] getDelegates() {
        return new Parser[] {};
    }

    // delegators


    public AnalexCParser(TokenStream input) {
        this(input, new RecognizerSharedState());
    }
    public AnalexCParser(TokenStream input, RecognizerSharedState state) {
        super(input, state);
    }

    public String[] getTokenNames() { return AnalexCParser.tokenNames; }
    public String getGrammarFileName() { return "C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g"; }


         private ArrayList<RecognitionException> errors = new ArrayList<RecognitionException>();
         public ArrayList<RecognitionException> getErrors() {
            return errors;
         }
         @Override
         public void reportError (RecognitionException e) {
            String msg = getErrorMessage(e, getTokenNames());
            System.err.println(msg);
            errors.add(e);
         }



    // $ANTLR start "entrada"
    // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:27:1: entrada : ( funcion )* programa_principal ;
    public final void entrada() throws RecognitionException {
        try {
            // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:27:8: ( ( funcion )* programa_principal )
            // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:27:10: ( funcion )* programa_principal
            {
            // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:27:10: ( funcion )*
            loop1:
            do {
                int alt1=2;
                int LA1_0 = input.LA(1);

                if ( (LA1_0==CHAR||LA1_0==FLOAT||LA1_0==INT||LA1_0==VOID) ) {
                    int LA1_1 = input.LA(2);

                    if ( (LA1_1==IDENT) ) {
                        alt1=1;
                    }


                }


                switch (alt1) {
            	case 1 :
            	    // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:27:10: funcion
            	    {
            	    pushFollow(FOLLOW_funcion_in_entrada48);
            	    funcion();

            	    state._fsp--;


            	    }
            	    break;

            	default :
            	    break loop1;
                }
            } while (true);


            pushFollow(FOLLOW_programa_principal_in_entrada51);
            programa_principal();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "entrada"



    // $ANTLR start "funcion"
    // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:29:1: funcion : cabecera_func cuerpo ;
    public final void funcion() throws RecognitionException {
        try {
            // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:29:8: ( cabecera_func cuerpo )
            // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:29:10: cabecera_func cuerpo
            {
            pushFollow(FOLLOW_cabecera_func_in_funcion58);
            cabecera_func();

            state._fsp--;


            pushFollow(FOLLOW_cuerpo_in_funcion60);
            cuerpo();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "funcion"



    // $ANTLR start "cabecera_func"
    // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:30:1: cabecera_func : tipo IDENT parametros ;
    public final void cabecera_func() throws RecognitionException {
        try {
            // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:30:14: ( tipo IDENT parametros )
            // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:30:16: tipo IDENT parametros
            {
            pushFollow(FOLLOW_tipo_in_cabecera_func66);
            tipo();

            state._fsp--;


            match(input,IDENT,FOLLOW_IDENT_in_cabecera_func68); 

            pushFollow(FOLLOW_parametros_in_cabecera_func70);
            parametros();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "cabecera_func"



    // $ANTLR start "cuerpo"
    // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:31:1: cuerpo : LLAVE_A instrucciones LLAVE_C ;
    public final void cuerpo() throws RecognitionException {
        try {
            // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:31:7: ( LLAVE_A instrucciones LLAVE_C )
            // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:31:9: LLAVE_A instrucciones LLAVE_C
            {
            match(input,LLAVE_A,FOLLOW_LLAVE_A_in_cuerpo76); 

            pushFollow(FOLLOW_instrucciones_in_cuerpo78);
            instrucciones();

            state._fsp--;


            match(input,LLAVE_C,FOLLOW_LLAVE_C_in_cuerpo80); 

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "cuerpo"



    // $ANTLR start "instrucciones"
    // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:33:1: instrucciones : ( regla_while | regla_if | dec_var | asignacion | salir_bucle | imprimir | ( llamada_funcion PUNTO_COMA ) | regla_for )* ;
    public final void instrucciones() throws RecognitionException {
        try {
            // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:33:14: ( ( regla_while | regla_if | dec_var | asignacion | salir_bucle | imprimir | ( llamada_funcion PUNTO_COMA ) | regla_for )* )
            // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:33:16: ( regla_while | regla_if | dec_var | asignacion | salir_bucle | imprimir | ( llamada_funcion PUNTO_COMA ) | regla_for )*
            {
            // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:33:16: ( regla_while | regla_if | dec_var | asignacion | salir_bucle | imprimir | ( llamada_funcion PUNTO_COMA ) | regla_for )*
            loop2:
            do {
                int alt2=9;
                switch ( input.LA(1) ) {
                case WHILE:
                    {
                    alt2=1;
                    }
                    break;
                case IF:
                    {
                    alt2=2;
                    }
                    break;
                case CHAR:
                case FLOAT:
                case INT:
                case VOID:
                    {
                    alt2=3;
                    }
                    break;
                case IDENT:
                    {
                    int LA2_5 = input.LA(2);

                    if ( (LA2_5==IGUAL) ) {
                        alt2=4;
                    }
                    else if ( (LA2_5==PARENTESIS_A) ) {
                        alt2=7;
                    }


                    }
                    break;
                case BREAK:
                    {
                    alt2=5;
                    }
                    break;
                case PRINTF:
                    {
                    alt2=6;
                    }
                    break;
                case FOR:
                    {
                    alt2=8;
                    }
                    break;

                }

                switch (alt2) {
            	case 1 :
            	    // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:33:17: regla_while
            	    {
            	    pushFollow(FOLLOW_regla_while_in_instrucciones88);
            	    regla_while();

            	    state._fsp--;


            	    }
            	    break;
            	case 2 :
            	    // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:33:29: regla_if
            	    {
            	    pushFollow(FOLLOW_regla_if_in_instrucciones90);
            	    regla_if();

            	    state._fsp--;


            	    }
            	    break;
            	case 3 :
            	    // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:33:38: dec_var
            	    {
            	    pushFollow(FOLLOW_dec_var_in_instrucciones92);
            	    dec_var();

            	    state._fsp--;


            	    }
            	    break;
            	case 4 :
            	    // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:33:46: asignacion
            	    {
            	    pushFollow(FOLLOW_asignacion_in_instrucciones94);
            	    asignacion();

            	    state._fsp--;


            	    }
            	    break;
            	case 5 :
            	    // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:33:57: salir_bucle
            	    {
            	    pushFollow(FOLLOW_salir_bucle_in_instrucciones96);
            	    salir_bucle();

            	    state._fsp--;


            	    }
            	    break;
            	case 6 :
            	    // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:33:69: imprimir
            	    {
            	    pushFollow(FOLLOW_imprimir_in_instrucciones98);
            	    imprimir();

            	    state._fsp--;


            	    }
            	    break;
            	case 7 :
            	    // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:33:78: ( llamada_funcion PUNTO_COMA )
            	    {
            	    // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:33:78: ( llamada_funcion PUNTO_COMA )
            	    // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:33:79: llamada_funcion PUNTO_COMA
            	    {
            	    pushFollow(FOLLOW_llamada_funcion_in_instrucciones101);
            	    llamada_funcion();

            	    state._fsp--;


            	    match(input,PUNTO_COMA,FOLLOW_PUNTO_COMA_in_instrucciones103); 

            	    }


            	    }
            	    break;
            	case 8 :
            	    // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:33:107: regla_for
            	    {
            	    pushFollow(FOLLOW_regla_for_in_instrucciones106);
            	    regla_for();

            	    state._fsp--;


            	    }
            	    break;

            	default :
            	    break loop2;
                }
            } while (true);


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "instrucciones"



    // $ANTLR start "programa_principal"
    // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:35:1: programa_principal : cabecera_main cuerpo ;
    public final void programa_principal() throws RecognitionException {
        try {
            // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:35:19: ( cabecera_main cuerpo )
            // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:35:21: cabecera_main cuerpo
            {
            pushFollow(FOLLOW_cabecera_main_in_programa_principal115);
            cabecera_main();

            state._fsp--;


            pushFollow(FOLLOW_cuerpo_in_programa_principal117);
            cuerpo();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "programa_principal"



    // $ANTLR start "cabecera_main"
    // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:36:1: cabecera_main : tipo MAIN parametros ;
    public final void cabecera_main() throws RecognitionException {
        try {
            // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:36:14: ( tipo MAIN parametros )
            // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:36:16: tipo MAIN parametros
            {
            pushFollow(FOLLOW_tipo_in_cabecera_main123);
            tipo();

            state._fsp--;


            match(input,MAIN,FOLLOW_MAIN_in_cabecera_main125); 

            pushFollow(FOLLOW_parametros_in_cabecera_main127);
            parametros();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "cabecera_main"



    // $ANTLR start "parametros"
    // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:38:1: parametros : PARENTESIS_A ( ( VOID )? | tipo parametro ( COMA tipo parametro )* ) PARENTESIS_C ;
    public final void parametros() throws RecognitionException {
        try {
            // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:38:11: ( PARENTESIS_A ( ( VOID )? | tipo parametro ( COMA tipo parametro )* ) PARENTESIS_C )
            // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:38:13: PARENTESIS_A ( ( VOID )? | tipo parametro ( COMA tipo parametro )* ) PARENTESIS_C
            {
            match(input,PARENTESIS_A,FOLLOW_PARENTESIS_A_in_parametros134); 

            // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:38:26: ( ( VOID )? | tipo parametro ( COMA tipo parametro )* )
            int alt5=2;
            switch ( input.LA(1) ) {
            case VOID:
                {
                int LA5_1 = input.LA(2);

                if ( (LA5_1==PARENTESIS_C) ) {
                    alt5=1;
                }
                else if ( (LA5_1==CADENA||LA5_1==IDENT||LA5_1==NUMERO||LA5_1==ASTERISCO) ) {
                    alt5=2;
                }
                else {
                    NoViableAltException nvae =
                        new NoViableAltException("", 5, 1, input);

                    throw nvae;

                }
                }
                break;
            case PARENTESIS_C:
                {
                alt5=1;
                }
                break;
            case CHAR:
            case FLOAT:
            case INT:
                {
                alt5=2;
                }
                break;
            default:
                NoViableAltException nvae =
                    new NoViableAltException("", 5, 0, input);

                throw nvae;

            }

            switch (alt5) {
                case 1 :
                    // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:38:27: ( VOID )?
                    {
                    // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:38:27: ( VOID )?
                    int alt3=2;
                    int LA3_0 = input.LA(1);

                    if ( (LA3_0==VOID) ) {
                        alt3=1;
                    }
                    switch (alt3) {
                        case 1 :
                            // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:38:28: VOID
                            {
                            match(input,VOID,FOLLOW_VOID_in_parametros138); 

                            }
                            break;

                    }


                    }
                    break;
                case 2 :
                    // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:38:37: tipo parametro ( COMA tipo parametro )*
                    {
                    pushFollow(FOLLOW_tipo_in_parametros144);
                    tipo();

                    state._fsp--;


                    pushFollow(FOLLOW_parametro_in_parametros146);
                    parametro();

                    state._fsp--;


                    // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:38:52: ( COMA tipo parametro )*
                    loop4:
                    do {
                        int alt4=2;
                        int LA4_0 = input.LA(1);

                        if ( (LA4_0==COMA) ) {
                            alt4=1;
                        }


                        switch (alt4) {
                    	case 1 :
                    	    // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:38:53: COMA tipo parametro
                    	    {
                    	    match(input,COMA,FOLLOW_COMA_in_parametros149); 

                    	    pushFollow(FOLLOW_tipo_in_parametros151);
                    	    tipo();

                    	    state._fsp--;


                    	    pushFollow(FOLLOW_parametro_in_parametros153);
                    	    parametro();

                    	    state._fsp--;


                    	    }
                    	    break;

                    	default :
                    	    break loop4;
                        }
                    } while (true);


                    }
                    break;

            }


            match(input,PARENTESIS_C,FOLLOW_PARENTESIS_C_in_parametros158); 

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "parametros"



    // $ANTLR start "parametro"
    // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:39:1: parametro : ( ( ( ASTERISCO )? IDENT ( CORCHETES )* ) | CADENA | NUMERO );
    public final void parametro() throws RecognitionException {
        try {
            // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:39:10: ( ( ( ASTERISCO )? IDENT ( CORCHETES )* ) | CADENA | NUMERO )
            int alt8=3;
            switch ( input.LA(1) ) {
            case IDENT:
            case ASTERISCO:
                {
                alt8=1;
                }
                break;
            case CADENA:
                {
                alt8=2;
                }
                break;
            case NUMERO:
                {
                alt8=3;
                }
                break;
            default:
                NoViableAltException nvae =
                    new NoViableAltException("", 8, 0, input);

                throw nvae;

            }

            switch (alt8) {
                case 1 :
                    // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:39:12: ( ( ASTERISCO )? IDENT ( CORCHETES )* )
                    {
                    // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:39:12: ( ( ASTERISCO )? IDENT ( CORCHETES )* )
                    // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:39:13: ( ASTERISCO )? IDENT ( CORCHETES )*
                    {
                    // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:39:13: ( ASTERISCO )?
                    int alt6=2;
                    int LA6_0 = input.LA(1);

                    if ( (LA6_0==ASTERISCO) ) {
                        alt6=1;
                    }
                    switch (alt6) {
                        case 1 :
                            // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:39:13: ASTERISCO
                            {
                            match(input,ASTERISCO,FOLLOW_ASTERISCO_in_parametro165); 

                            }
                            break;

                    }


                    match(input,IDENT,FOLLOW_IDENT_in_parametro168); 

                    // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:39:30: ( CORCHETES )*
                    loop7:
                    do {
                        int alt7=2;
                        int LA7_0 = input.LA(1);

                        if ( (LA7_0==CORCHETES) ) {
                            alt7=1;
                        }


                        switch (alt7) {
                    	case 1 :
                    	    // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:39:30: CORCHETES
                    	    {
                    	    match(input,CORCHETES,FOLLOW_CORCHETES_in_parametro170); 

                    	    }
                    	    break;

                    	default :
                    	    break loop7;
                        }
                    } while (true);


                    }


                    }
                    break;
                case 2 :
                    // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:39:44: CADENA
                    {
                    match(input,CADENA,FOLLOW_CADENA_in_parametro176); 

                    }
                    break;
                case 3 :
                    // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:39:53: NUMERO
                    {
                    match(input,NUMERO,FOLLOW_NUMERO_in_parametro180); 

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "parametro"



    // $ANTLR start "tipo"
    // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:41:1: tipo : ( INT | CHAR | FLOAT | VOID );
    public final void tipo() throws RecognitionException {
        try {
            // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:41:5: ( INT | CHAR | FLOAT | VOID )
            // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:
            {
            if ( input.LA(1)==CHAR||input.LA(1)==FLOAT||input.LA(1)==INT||input.LA(1)==VOID ) {
                input.consume();
                state.errorRecovery=false;
            }
            else {
                MismatchedSetException mse = new MismatchedSetException(null,input);
                throw mse;
            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "tipo"



    // $ANTLR start "dec_var"
    // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:43:1: dec_var : tipo IDENT ( COMA IDENT )* PUNTO_COMA ;
    public final void dec_var() throws RecognitionException {
        try {
            // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:43:8: ( tipo IDENT ( COMA IDENT )* PUNTO_COMA )
            // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:43:10: tipo IDENT ( COMA IDENT )* PUNTO_COMA
            {
            pushFollow(FOLLOW_tipo_in_dec_var200);
            tipo();

            state._fsp--;


            match(input,IDENT,FOLLOW_IDENT_in_dec_var202); 

            // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:43:21: ( COMA IDENT )*
            loop9:
            do {
                int alt9=2;
                int LA9_0 = input.LA(1);

                if ( (LA9_0==COMA) ) {
                    alt9=1;
                }


                switch (alt9) {
            	case 1 :
            	    // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:43:22: COMA IDENT
            	    {
            	    match(input,COMA,FOLLOW_COMA_in_dec_var205); 

            	    match(input,IDENT,FOLLOW_IDENT_in_dec_var207); 

            	    }
            	    break;

            	default :
            	    break loop9;
                }
            } while (true);


            match(input,PUNTO_COMA,FOLLOW_PUNTO_COMA_in_dec_var211); 

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "dec_var"



    // $ANTLR start "asignacion"
    // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:44:1: asignacion : IDENT IGUAL ( expr | caracter | llamada_funcion | condicional_aritm ) PUNTO_COMA ;
    public final void asignacion() throws RecognitionException {
        try {
            // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:44:11: ( IDENT IGUAL ( expr | caracter | llamada_funcion | condicional_aritm ) PUNTO_COMA )
            // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:44:13: IDENT IGUAL ( expr | caracter | llamada_funcion | condicional_aritm ) PUNTO_COMA
            {
            match(input,IDENT,FOLLOW_IDENT_in_asignacion217); 

            match(input,IGUAL,FOLLOW_IGUAL_in_asignacion219); 

            // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:44:25: ( expr | caracter | llamada_funcion | condicional_aritm )
            int alt10=4;
            alt10 = dfa10.predict(input);
            switch (alt10) {
                case 1 :
                    // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:44:26: expr
                    {
                    pushFollow(FOLLOW_expr_in_asignacion222);
                    expr();

                    state._fsp--;


                    }
                    break;
                case 2 :
                    // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:44:31: caracter
                    {
                    pushFollow(FOLLOW_caracter_in_asignacion224);
                    caracter();

                    state._fsp--;


                    }
                    break;
                case 3 :
                    // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:44:40: llamada_funcion
                    {
                    pushFollow(FOLLOW_llamada_funcion_in_asignacion226);
                    llamada_funcion();

                    state._fsp--;


                    }
                    break;
                case 4 :
                    // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:44:56: condicional_aritm
                    {
                    pushFollow(FOLLOW_condicional_aritm_in_asignacion228);
                    condicional_aritm();

                    state._fsp--;


                    }
                    break;

            }


            match(input,PUNTO_COMA,FOLLOW_PUNTO_COMA_in_asignacion231); 

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "asignacion"



    // $ANTLR start "caracter"
    // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:45:1: caracter : COMILLA LETRA COMILLA ;
    public final void caracter() throws RecognitionException {
        try {
            // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:45:9: ( COMILLA LETRA COMILLA )
            // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:45:11: COMILLA LETRA COMILLA
            {
            match(input,COMILLA,FOLLOW_COMILLA_in_caracter237); 

            match(input,LETRA,FOLLOW_LETRA_in_caracter239); 

            match(input,COMILLA,FOLLOW_COMILLA_in_caracter241); 

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "caracter"



    // $ANTLR start "regla_while"
    // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:47:1: regla_while : WHILE condicion cuerpo ;
    public final void regla_while() throws RecognitionException {
        try {
            // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:47:12: ( WHILE condicion cuerpo )
            // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:47:14: WHILE condicion cuerpo
            {
            match(input,WHILE,FOLLOW_WHILE_in_regla_while248); 

            pushFollow(FOLLOW_condicion_in_regla_while250);
            condicion();

            state._fsp--;


            pushFollow(FOLLOW_cuerpo_in_regla_while252);
            cuerpo();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "regla_while"



    // $ANTLR start "condicion"
    // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:48:1: condicion : ( NOT )? PARENTESIS_A comparacion PARENTESIS_C ( ( AND | OR ) ( NOT )? PARENTESIS_A comparacion PARENTESIS_C )* ;
    public final void condicion() throws RecognitionException {
        try {
            // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:48:10: ( ( NOT )? PARENTESIS_A comparacion PARENTESIS_C ( ( AND | OR ) ( NOT )? PARENTESIS_A comparacion PARENTESIS_C )* )
            // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:48:12: ( NOT )? PARENTESIS_A comparacion PARENTESIS_C ( ( AND | OR ) ( NOT )? PARENTESIS_A comparacion PARENTESIS_C )*
            {
            // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:48:12: ( NOT )?
            int alt11=2;
            int LA11_0 = input.LA(1);

            if ( (LA11_0==NOT) ) {
                alt11=1;
            }
            switch (alt11) {
                case 1 :
                    // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:48:12: NOT
                    {
                    match(input,NOT,FOLLOW_NOT_in_condicion258); 

                    }
                    break;

            }


            match(input,PARENTESIS_A,FOLLOW_PARENTESIS_A_in_condicion261); 

            pushFollow(FOLLOW_comparacion_in_condicion263);
            comparacion();

            state._fsp--;


            match(input,PARENTESIS_C,FOLLOW_PARENTESIS_C_in_condicion265); 

            // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:48:55: ( ( AND | OR ) ( NOT )? PARENTESIS_A comparacion PARENTESIS_C )*
            loop13:
            do {
                int alt13=2;
                int LA13_0 = input.LA(1);

                if ( (LA13_0==AND||LA13_0==OR) ) {
                    alt13=1;
                }


                switch (alt13) {
            	case 1 :
            	    // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:48:56: ( AND | OR ) ( NOT )? PARENTESIS_A comparacion PARENTESIS_C
            	    {
            	    if ( input.LA(1)==AND||input.LA(1)==OR ) {
            	        input.consume();
            	        state.errorRecovery=false;
            	    }
            	    else {
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        throw mse;
            	    }


            	    // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:48:65: ( NOT )?
            	    int alt12=2;
            	    int LA12_0 = input.LA(1);

            	    if ( (LA12_0==NOT) ) {
            	        alt12=1;
            	    }
            	    switch (alt12) {
            	        case 1 :
            	            // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:48:65: NOT
            	            {
            	            match(input,NOT,FOLLOW_NOT_in_condicion274); 

            	            }
            	            break;

            	    }


            	    match(input,PARENTESIS_A,FOLLOW_PARENTESIS_A_in_condicion277); 

            	    pushFollow(FOLLOW_comparacion_in_condicion279);
            	    comparacion();

            	    state._fsp--;


            	    match(input,PARENTESIS_C,FOLLOW_PARENTESIS_C_in_condicion281); 

            	    }
            	    break;

            	default :
            	    break loop13;
                }
            } while (true);


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "condicion"



    // $ANTLR start "comparacion"
    // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:49:1: comparacion : expr COMPARADOR expr ;
    public final void comparacion() throws RecognitionException {
        try {
            // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:49:12: ( expr COMPARADOR expr )
            // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:49:14: expr COMPARADOR expr
            {
            pushFollow(FOLLOW_expr_in_comparacion289);
            expr();

            state._fsp--;


            match(input,COMPARADOR,FOLLOW_COMPARADOR_in_comparacion291); 

            pushFollow(FOLLOW_expr_in_comparacion293);
            expr();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "comparacion"



    // $ANTLR start "expr"
    // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:51:1: expr : ( CAMBIO_SIGNO )? ( NUMERO | ( IDENT ) ) ( OPERADOR ( CAMBIO_SIGNO )? ( NUMERO | ( IDENT ) ) )* ;
    public final void expr() throws RecognitionException {
        try {
            // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:51:5: ( ( CAMBIO_SIGNO )? ( NUMERO | ( IDENT ) ) ( OPERADOR ( CAMBIO_SIGNO )? ( NUMERO | ( IDENT ) ) )* )
            // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:51:7: ( CAMBIO_SIGNO )? ( NUMERO | ( IDENT ) ) ( OPERADOR ( CAMBIO_SIGNO )? ( NUMERO | ( IDENT ) ) )*
            {
            // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:51:7: ( CAMBIO_SIGNO )?
            int alt14=2;
            int LA14_0 = input.LA(1);

            if ( (LA14_0==CAMBIO_SIGNO) ) {
                alt14=1;
            }
            switch (alt14) {
                case 1 :
                    // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:51:7: CAMBIO_SIGNO
                    {
                    match(input,CAMBIO_SIGNO,FOLLOW_CAMBIO_SIGNO_in_expr300); 

                    }
                    break;

            }


            if ( input.LA(1)==IDENT||input.LA(1)==NUMERO ) {
                input.consume();
                state.errorRecovery=false;
            }
            else {
                MismatchedSetException mse = new MismatchedSetException(null,input);
                throw mse;
            }


            // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:51:38: ( OPERADOR ( CAMBIO_SIGNO )? ( NUMERO | ( IDENT ) ) )*
            loop16:
            do {
                int alt16=2;
                int LA16_0 = input.LA(1);

                if ( (LA16_0==OPERADOR) ) {
                    alt16=1;
                }


                switch (alt16) {
            	case 1 :
            	    // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:51:39: OPERADOR ( CAMBIO_SIGNO )? ( NUMERO | ( IDENT ) )
            	    {
            	    match(input,OPERADOR,FOLLOW_OPERADOR_in_expr312); 

            	    // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:51:48: ( CAMBIO_SIGNO )?
            	    int alt15=2;
            	    int LA15_0 = input.LA(1);

            	    if ( (LA15_0==CAMBIO_SIGNO) ) {
            	        alt15=1;
            	    }
            	    switch (alt15) {
            	        case 1 :
            	            // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:51:48: CAMBIO_SIGNO
            	            {
            	            match(input,CAMBIO_SIGNO,FOLLOW_CAMBIO_SIGNO_in_expr314); 

            	            }
            	            break;

            	    }


            	    if ( input.LA(1)==IDENT||input.LA(1)==NUMERO ) {
            	        input.consume();
            	        state.errorRecovery=false;
            	    }
            	    else {
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        throw mse;
            	    }


            	    }
            	    break;

            	default :
            	    break loop16;
                }
            } while (true);


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "expr"



    // $ANTLR start "imprimir"
    // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:53:1: imprimir : PRINTF PARENTESIS_A CADENA ( COMA IDENT )* PARENTESIS_C PUNTO_COMA ;
    public final void imprimir() throws RecognitionException {
        try {
            // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:53:9: ( PRINTF PARENTESIS_A CADENA ( COMA IDENT )* PARENTESIS_C PUNTO_COMA )
            // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:53:11: PRINTF PARENTESIS_A CADENA ( COMA IDENT )* PARENTESIS_C PUNTO_COMA
            {
            match(input,PRINTF,FOLLOW_PRINTF_in_imprimir332); 

            match(input,PARENTESIS_A,FOLLOW_PARENTESIS_A_in_imprimir334); 

            match(input,CADENA,FOLLOW_CADENA_in_imprimir336); 

            // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:53:38: ( COMA IDENT )*
            loop17:
            do {
                int alt17=2;
                int LA17_0 = input.LA(1);

                if ( (LA17_0==COMA) ) {
                    alt17=1;
                }


                switch (alt17) {
            	case 1 :
            	    // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:53:39: COMA IDENT
            	    {
            	    match(input,COMA,FOLLOW_COMA_in_imprimir339); 

            	    match(input,IDENT,FOLLOW_IDENT_in_imprimir341); 

            	    }
            	    break;

            	default :
            	    break loop17;
                }
            } while (true);


            match(input,PARENTESIS_C,FOLLOW_PARENTESIS_C_in_imprimir345); 

            match(input,PUNTO_COMA,FOLLOW_PUNTO_COMA_in_imprimir347); 

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "imprimir"



    // $ANTLR start "salir_bucle"
    // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:54:1: salir_bucle : BREAK PUNTO_COMA ;
    public final void salir_bucle() throws RecognitionException {
        try {
            // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:54:12: ( BREAK PUNTO_COMA )
            // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:54:14: BREAK PUNTO_COMA
            {
            match(input,BREAK,FOLLOW_BREAK_in_salir_bucle353); 

            match(input,PUNTO_COMA,FOLLOW_PUNTO_COMA_in_salir_bucle355); 

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "salir_bucle"



    // $ANTLR start "llamada_funcion"
    // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:55:1: llamada_funcion : IDENT PARENTESIS_A ( parametro ( COMA parametro )* )? PARENTESIS_C ;
    public final void llamada_funcion() throws RecognitionException {
        try {
            // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:55:16: ( IDENT PARENTESIS_A ( parametro ( COMA parametro )* )? PARENTESIS_C )
            // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:55:18: IDENT PARENTESIS_A ( parametro ( COMA parametro )* )? PARENTESIS_C
            {
            match(input,IDENT,FOLLOW_IDENT_in_llamada_funcion361); 

            match(input,PARENTESIS_A,FOLLOW_PARENTESIS_A_in_llamada_funcion363); 

            // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:55:37: ( parametro ( COMA parametro )* )?
            int alt19=2;
            int LA19_0 = input.LA(1);

            if ( (LA19_0==CADENA||LA19_0==IDENT||LA19_0==NUMERO||LA19_0==ASTERISCO) ) {
                alt19=1;
            }
            switch (alt19) {
                case 1 :
                    // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:55:38: parametro ( COMA parametro )*
                    {
                    pushFollow(FOLLOW_parametro_in_llamada_funcion366);
                    parametro();

                    state._fsp--;


                    // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:55:48: ( COMA parametro )*
                    loop18:
                    do {
                        int alt18=2;
                        int LA18_0 = input.LA(1);

                        if ( (LA18_0==COMA) ) {
                            alt18=1;
                        }


                        switch (alt18) {
                    	case 1 :
                    	    // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:55:49: COMA parametro
                    	    {
                    	    match(input,COMA,FOLLOW_COMA_in_llamada_funcion369); 

                    	    pushFollow(FOLLOW_parametro_in_llamada_funcion371);
                    	    parametro();

                    	    state._fsp--;


                    	    }
                    	    break;

                    	default :
                    	    break loop18;
                        }
                    } while (true);


                    }
                    break;

            }


            match(input,PARENTESIS_C,FOLLOW_PARENTESIS_C_in_llamada_funcion377); 

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "llamada_funcion"



    // $ANTLR start "regla_if"
    // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:57:1: regla_if : IF condicion cuerpo ;
    public final void regla_if() throws RecognitionException {
        try {
            // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:57:9: ( IF condicion cuerpo )
            // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:57:11: IF condicion cuerpo
            {
            match(input,IF,FOLLOW_IF_in_regla_if384); 

            pushFollow(FOLLOW_condicion_in_regla_if386);
            condicion();

            state._fsp--;


            pushFollow(FOLLOW_cuerpo_in_regla_if388);
            cuerpo();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "regla_if"



    // $ANTLR start "condicional_aritm"
    // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:59:1: condicional_aritm : comparacion INTERROGANTE expr DOS_PUNTOS expr PUNTO_COMA ;
    public final void condicional_aritm() throws RecognitionException {
        try {
            // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:59:18: ( comparacion INTERROGANTE expr DOS_PUNTOS expr PUNTO_COMA )
            // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:59:20: comparacion INTERROGANTE expr DOS_PUNTOS expr PUNTO_COMA
            {
            pushFollow(FOLLOW_comparacion_in_condicional_aritm395);
            comparacion();

            state._fsp--;


            match(input,INTERROGANTE,FOLLOW_INTERROGANTE_in_condicional_aritm397); 

            pushFollow(FOLLOW_expr_in_condicional_aritm399);
            expr();

            state._fsp--;


            match(input,DOS_PUNTOS,FOLLOW_DOS_PUNTOS_in_condicional_aritm401); 

            pushFollow(FOLLOW_expr_in_condicional_aritm403);
            expr();

            state._fsp--;


            match(input,PUNTO_COMA,FOLLOW_PUNTO_COMA_in_condicional_aritm405); 

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "condicional_aritm"



    // $ANTLR start "regla_for"
    // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:61:1: regla_for : FOR PARENTESIS_A iteracion_for PARENTESIS_C cuerpo ;
    public final void regla_for() throws RecognitionException {
        try {
            // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:61:10: ( FOR PARENTESIS_A iteracion_for PARENTESIS_C cuerpo )
            // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:61:12: FOR PARENTESIS_A iteracion_for PARENTESIS_C cuerpo
            {
            match(input,FOR,FOLLOW_FOR_in_regla_for412); 

            match(input,PARENTESIS_A,FOLLOW_PARENTESIS_A_in_regla_for414); 

            pushFollow(FOLLOW_iteracion_for_in_regla_for416);
            iteracion_for();

            state._fsp--;


            match(input,PARENTESIS_C,FOLLOW_PARENTESIS_C_in_regla_for418); 

            pushFollow(FOLLOW_cuerpo_in_regla_for420);
            cuerpo();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "regla_for"



    // $ANTLR start "iteracion_for"
    // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:62:1: iteracion_for : ( ( ( INT )? asignacion ) | PUNTO_COMA ) ( comparacion )? PUNTO_COMA ( incremento | decremento )? ;
    public final void iteracion_for() throws RecognitionException {
        try {
            // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:62:14: ( ( ( ( INT )? asignacion ) | PUNTO_COMA ) ( comparacion )? PUNTO_COMA ( incremento | decremento )? )
            // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:62:16: ( ( ( INT )? asignacion ) | PUNTO_COMA ) ( comparacion )? PUNTO_COMA ( incremento | decremento )?
            {
            // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:62:16: ( ( ( INT )? asignacion ) | PUNTO_COMA )
            int alt21=2;
            int LA21_0 = input.LA(1);

            if ( (LA21_0==IDENT||LA21_0==INT) ) {
                alt21=1;
            }
            else if ( (LA21_0==PUNTO_COMA) ) {
                alt21=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 21, 0, input);

                throw nvae;

            }
            switch (alt21) {
                case 1 :
                    // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:62:17: ( ( INT )? asignacion )
                    {
                    // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:62:17: ( ( INT )? asignacion )
                    // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:62:18: ( INT )? asignacion
                    {
                    // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:62:18: ( INT )?
                    int alt20=2;
                    int LA20_0 = input.LA(1);

                    if ( (LA20_0==INT) ) {
                        alt20=1;
                    }
                    switch (alt20) {
                        case 1 :
                            // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:62:18: INT
                            {
                            match(input,INT,FOLLOW_INT_in_iteracion_for428); 

                            }
                            break;

                    }


                    pushFollow(FOLLOW_asignacion_in_iteracion_for431);
                    asignacion();

                    state._fsp--;


                    }


                    }
                    break;
                case 2 :
                    // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:62:35: PUNTO_COMA
                    {
                    match(input,PUNTO_COMA,FOLLOW_PUNTO_COMA_in_iteracion_for434); 

                    }
                    break;

            }


            // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:62:47: ( comparacion )?
            int alt22=2;
            int LA22_0 = input.LA(1);

            if ( (LA22_0==CAMBIO_SIGNO||LA22_0==IDENT||LA22_0==NUMERO) ) {
                alt22=1;
            }
            switch (alt22) {
                case 1 :
                    // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:62:47: comparacion
                    {
                    pushFollow(FOLLOW_comparacion_in_iteracion_for437);
                    comparacion();

                    state._fsp--;


                    }
                    break;

            }


            match(input,PUNTO_COMA,FOLLOW_PUNTO_COMA_in_iteracion_for440); 

            // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:62:71: ( incremento | decremento )?
            int alt23=3;
            int LA23_0 = input.LA(1);

            if ( (LA23_0==PARENTESIS_A) ) {
                int LA23_1 = input.LA(2);

                if ( (LA23_1==IDENT) ) {
                    switch ( input.LA(3) ) {
                        case PARENTESIS_C:
                            {
                            int LA23_4 = input.LA(4);

                            if ( (LA23_4==INCREMENTO) ) {
                                alt23=1;
                            }
                            else if ( (LA23_4==DECREMENTO) ) {
                                alt23=2;
                            }
                            }
                            break;
                        case INCREMENTO:
                            {
                            alt23=1;
                            }
                            break;
                        case DECREMENTO:
                            {
                            alt23=2;
                            }
                            break;
                    }

                }
            }
            else if ( (LA23_0==IDENT) ) {
                switch ( input.LA(2) ) {
                    case PARENTESIS_C:
                        {
                        int LA23_4 = input.LA(3);

                        if ( (LA23_4==INCREMENTO) ) {
                            alt23=1;
                        }
                        else if ( (LA23_4==DECREMENTO) ) {
                            alt23=2;
                        }
                        }
                        break;
                    case INCREMENTO:
                        {
                        alt23=1;
                        }
                        break;
                    case DECREMENTO:
                        {
                        alt23=2;
                        }
                        break;
                }

            }
            switch (alt23) {
                case 1 :
                    // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:62:72: incremento
                    {
                    pushFollow(FOLLOW_incremento_in_iteracion_for443);
                    incremento();

                    state._fsp--;


                    }
                    break;
                case 2 :
                    // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:62:83: decremento
                    {
                    pushFollow(FOLLOW_decremento_in_iteracion_for445);
                    decremento();

                    state._fsp--;


                    }
                    break;

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "iteracion_for"



    // $ANTLR start "incremento"
    // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:64:1: incremento : ( PARENTESIS_A )? IDENT ( PARENTESIS_C )? INCREMENTO ;
    public final void incremento() throws RecognitionException {
        try {
            // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:64:11: ( ( PARENTESIS_A )? IDENT ( PARENTESIS_C )? INCREMENTO )
            // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:64:13: ( PARENTESIS_A )? IDENT ( PARENTESIS_C )? INCREMENTO
            {
            // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:64:13: ( PARENTESIS_A )?
            int alt24=2;
            int LA24_0 = input.LA(1);

            if ( (LA24_0==PARENTESIS_A) ) {
                alt24=1;
            }
            switch (alt24) {
                case 1 :
                    // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:64:13: PARENTESIS_A
                    {
                    match(input,PARENTESIS_A,FOLLOW_PARENTESIS_A_in_incremento454); 

                    }
                    break;

            }


            match(input,IDENT,FOLLOW_IDENT_in_incremento457); 

            // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:64:33: ( PARENTESIS_C )?
            int alt25=2;
            int LA25_0 = input.LA(1);

            if ( (LA25_0==PARENTESIS_C) ) {
                alt25=1;
            }
            switch (alt25) {
                case 1 :
                    // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:64:33: PARENTESIS_C
                    {
                    match(input,PARENTESIS_C,FOLLOW_PARENTESIS_C_in_incremento459); 

                    }
                    break;

            }


            match(input,INCREMENTO,FOLLOW_INCREMENTO_in_incremento462); 

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "incremento"



    // $ANTLR start "decremento"
    // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:65:1: decremento : ( PARENTESIS_A )? IDENT ( PARENTESIS_C )? DECREMENTO ;
    public final void decremento() throws RecognitionException {
        try {
            // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:65:11: ( ( PARENTESIS_A )? IDENT ( PARENTESIS_C )? DECREMENTO )
            // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:65:13: ( PARENTESIS_A )? IDENT ( PARENTESIS_C )? DECREMENTO
            {
            // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:65:13: ( PARENTESIS_A )?
            int alt26=2;
            int LA26_0 = input.LA(1);

            if ( (LA26_0==PARENTESIS_A) ) {
                alt26=1;
            }
            switch (alt26) {
                case 1 :
                    // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:65:13: PARENTESIS_A
                    {
                    match(input,PARENTESIS_A,FOLLOW_PARENTESIS_A_in_decremento468); 

                    }
                    break;

            }


            match(input,IDENT,FOLLOW_IDENT_in_decremento471); 

            // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:65:33: ( PARENTESIS_C )?
            int alt27=2;
            int LA27_0 = input.LA(1);

            if ( (LA27_0==PARENTESIS_C) ) {
                alt27=1;
            }
            switch (alt27) {
                case 1 :
                    // C:\\Users\\usuario\\workspace\\Practica6-PL\\src\\main\\java\\practica6\\AnalexCParser.g:65:33: PARENTESIS_C
                    {
                    match(input,PARENTESIS_C,FOLLOW_PARENTESIS_C_in_decremento473); 

                    }
                    break;

            }


            match(input,DECREMENTO,FOLLOW_DECREMENTO_in_decremento476); 

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "decremento"

    // Delegated rules


    protected DFA10 dfa10 = new DFA10(this);
    static final String DFA10_eotS =
        "\13\uffff";
    static final String DFA10_eofS =
        "\13\uffff";
    static final String DFA10_minS =
        "\1\10\1\26\1\15\1\uffff\1\15\1\uffff\1\10\2\uffff\1\26\1\15";
    static final String DFA10_maxS =
        "\2\41\1\47\1\uffff\1\47\1\uffff\1\41\2\uffff\1\41\1\47";
    static final String DFA10_acceptS =
        "\3\uffff\1\2\1\uffff\1\3\1\uffff\1\1\1\4\2\uffff";
    static final String DFA10_specialS =
        "\13\uffff}>";
    static final String[] DFA10_transitionS = {
            "\1\1\2\uffff\1\3\12\uffff\1\2\12\uffff\1\4",
            "\1\4\12\uffff\1\4",
            "\1\10\24\uffff\1\6\1\uffff\1\5\2\uffff\1\7",
            "",
            "\1\10\24\uffff\1\6\4\uffff\1\7",
            "",
            "\1\11\15\uffff\1\12\12\uffff\1\12",
            "",
            "",
            "\1\12\12\uffff\1\12",
            "\1\10\24\uffff\1\6\4\uffff\1\7"
    };

    static final short[] DFA10_eot = DFA.unpackEncodedString(DFA10_eotS);
    static final short[] DFA10_eof = DFA.unpackEncodedString(DFA10_eofS);
    static final char[] DFA10_min = DFA.unpackEncodedStringToUnsignedChars(DFA10_minS);
    static final char[] DFA10_max = DFA.unpackEncodedStringToUnsignedChars(DFA10_maxS);
    static final short[] DFA10_accept = DFA.unpackEncodedString(DFA10_acceptS);
    static final short[] DFA10_special = DFA.unpackEncodedString(DFA10_specialS);
    static final short[][] DFA10_transition;

    static {
        int numStates = DFA10_transitionS.length;
        DFA10_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA10_transition[i] = DFA.unpackEncodedString(DFA10_transitionS[i]);
        }
    }

    class DFA10 extends DFA {

        public DFA10(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 10;
            this.eot = DFA10_eot;
            this.eof = DFA10_eof;
            this.min = DFA10_min;
            this.max = DFA10_max;
            this.accept = DFA10_accept;
            this.special = DFA10_special;
            this.transition = DFA10_transition;
        }
        public String getDescription() {
            return "44:25: ( expr | caracter | llamada_funcion | condicional_aritm )";
        }
    }
 

    public static final BitSet FOLLOW_funcion_in_entrada48 = new BitSet(new long[]{0x0000010004100200L});
    public static final BitSet FOLLOW_programa_principal_in_entrada51 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_cabecera_func_in_funcion58 = new BitSet(new long[]{0x0000000020000000L});
    public static final BitSet FOLLOW_cuerpo_in_funcion60 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_tipo_in_cabecera_func66 = new BitSet(new long[]{0x0000000000400000L});
    public static final BitSet FOLLOW_IDENT_in_cabecera_func68 = new BitSet(new long[]{0x0000001000000000L});
    public static final BitSet FOLLOW_parametros_in_cabecera_func70 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LLAVE_A_in_cuerpo76 = new BitSet(new long[]{0x0000034044F00240L});
    public static final BitSet FOLLOW_instrucciones_in_cuerpo78 = new BitSet(new long[]{0x0000000040000000L});
    public static final BitSet FOLLOW_LLAVE_C_in_cuerpo80 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_regla_while_in_instrucciones88 = new BitSet(new long[]{0x0000034004F00242L});
    public static final BitSet FOLLOW_regla_if_in_instrucciones90 = new BitSet(new long[]{0x0000034004F00242L});
    public static final BitSet FOLLOW_dec_var_in_instrucciones92 = new BitSet(new long[]{0x0000034004F00242L});
    public static final BitSet FOLLOW_asignacion_in_instrucciones94 = new BitSet(new long[]{0x0000034004F00242L});
    public static final BitSet FOLLOW_salir_bucle_in_instrucciones96 = new BitSet(new long[]{0x0000034004F00242L});
    public static final BitSet FOLLOW_imprimir_in_instrucciones98 = new BitSet(new long[]{0x0000034004F00242L});
    public static final BitSet FOLLOW_llamada_funcion_in_instrucciones101 = new BitSet(new long[]{0x0000008000000000L});
    public static final BitSet FOLLOW_PUNTO_COMA_in_instrucciones103 = new BitSet(new long[]{0x0000034004F00242L});
    public static final BitSet FOLLOW_regla_for_in_instrucciones106 = new BitSet(new long[]{0x0000034004F00242L});
    public static final BitSet FOLLOW_cabecera_main_in_programa_principal115 = new BitSet(new long[]{0x0000000020000000L});
    public static final BitSet FOLLOW_cuerpo_in_programa_principal117 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_tipo_in_cabecera_main123 = new BitSet(new long[]{0x0000000080000000L});
    public static final BitSet FOLLOW_MAIN_in_cabecera_main125 = new BitSet(new long[]{0x0000001000000000L});
    public static final BitSet FOLLOW_parametros_in_cabecera_main127 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_PARENTESIS_A_in_parametros134 = new BitSet(new long[]{0x0000012004100200L});
    public static final BitSet FOLLOW_VOID_in_parametros138 = new BitSet(new long[]{0x0000002000000000L});
    public static final BitSet FOLLOW_tipo_in_parametros144 = new BitSet(new long[]{0x0000040200400080L});
    public static final BitSet FOLLOW_parametro_in_parametros146 = new BitSet(new long[]{0x0000002000000400L});
    public static final BitSet FOLLOW_COMA_in_parametros149 = new BitSet(new long[]{0x0000010004100200L});
    public static final BitSet FOLLOW_tipo_in_parametros151 = new BitSet(new long[]{0x0000040200400080L});
    public static final BitSet FOLLOW_parametro_in_parametros153 = new BitSet(new long[]{0x0000002000000400L});
    public static final BitSet FOLLOW_PARENTESIS_C_in_parametros158 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_ASTERISCO_in_parametro165 = new BitSet(new long[]{0x0000000000400000L});
    public static final BitSet FOLLOW_IDENT_in_parametro168 = new BitSet(new long[]{0x0000000000004002L});
    public static final BitSet FOLLOW_CORCHETES_in_parametro170 = new BitSet(new long[]{0x0000000000004002L});
    public static final BitSet FOLLOW_CADENA_in_parametro176 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_NUMERO_in_parametro180 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_tipo_in_dec_var200 = new BitSet(new long[]{0x0000000000400000L});
    public static final BitSet FOLLOW_IDENT_in_dec_var202 = new BitSet(new long[]{0x0000008000000400L});
    public static final BitSet FOLLOW_COMA_in_dec_var205 = new BitSet(new long[]{0x0000000000400000L});
    public static final BitSet FOLLOW_IDENT_in_dec_var207 = new BitSet(new long[]{0x0000008000000400L});
    public static final BitSet FOLLOW_PUNTO_COMA_in_dec_var211 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IDENT_in_asignacion217 = new BitSet(new long[]{0x0000000001000000L});
    public static final BitSet FOLLOW_IGUAL_in_asignacion219 = new BitSet(new long[]{0x0000000200400900L});
    public static final BitSet FOLLOW_expr_in_asignacion222 = new BitSet(new long[]{0x0000008000000000L});
    public static final BitSet FOLLOW_caracter_in_asignacion224 = new BitSet(new long[]{0x0000008000000000L});
    public static final BitSet FOLLOW_llamada_funcion_in_asignacion226 = new BitSet(new long[]{0x0000008000000000L});
    public static final BitSet FOLLOW_condicional_aritm_in_asignacion228 = new BitSet(new long[]{0x0000008000000000L});
    public static final BitSet FOLLOW_PUNTO_COMA_in_asignacion231 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_COMILLA_in_caracter237 = new BitSet(new long[]{0x0000000010000000L});
    public static final BitSet FOLLOW_LETRA_in_caracter239 = new BitSet(new long[]{0x0000000000000800L});
    public static final BitSet FOLLOW_COMILLA_in_caracter241 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_WHILE_in_regla_while248 = new BitSet(new long[]{0x0000001100000000L});
    public static final BitSet FOLLOW_condicion_in_regla_while250 = new BitSet(new long[]{0x0000000020000000L});
    public static final BitSet FOLLOW_cuerpo_in_regla_while252 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_NOT_in_condicion258 = new BitSet(new long[]{0x0000001000000000L});
    public static final BitSet FOLLOW_PARENTESIS_A_in_condicion261 = new BitSet(new long[]{0x0000000200400100L});
    public static final BitSet FOLLOW_comparacion_in_condicion263 = new BitSet(new long[]{0x0000002000000000L});
    public static final BitSet FOLLOW_PARENTESIS_C_in_condicion265 = new BitSet(new long[]{0x0000000800000012L});
    public static final BitSet FOLLOW_set_in_condicion268 = new BitSet(new long[]{0x0000001100000000L});
    public static final BitSet FOLLOW_NOT_in_condicion274 = new BitSet(new long[]{0x0000001000000000L});
    public static final BitSet FOLLOW_PARENTESIS_A_in_condicion277 = new BitSet(new long[]{0x0000000200400100L});
    public static final BitSet FOLLOW_comparacion_in_condicion279 = new BitSet(new long[]{0x0000002000000000L});
    public static final BitSet FOLLOW_PARENTESIS_C_in_condicion281 = new BitSet(new long[]{0x0000000800000012L});
    public static final BitSet FOLLOW_expr_in_comparacion289 = new BitSet(new long[]{0x0000000000002000L});
    public static final BitSet FOLLOW_COMPARADOR_in_comparacion291 = new BitSet(new long[]{0x0000000200400100L});
    public static final BitSet FOLLOW_expr_in_comparacion293 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_CAMBIO_SIGNO_in_expr300 = new BitSet(new long[]{0x0000000200400000L});
    public static final BitSet FOLLOW_set_in_expr303 = new BitSet(new long[]{0x0000000400000002L});
    public static final BitSet FOLLOW_OPERADOR_in_expr312 = new BitSet(new long[]{0x0000000200400100L});
    public static final BitSet FOLLOW_CAMBIO_SIGNO_in_expr314 = new BitSet(new long[]{0x0000000200400000L});
    public static final BitSet FOLLOW_set_in_expr317 = new BitSet(new long[]{0x0000000400000002L});
    public static final BitSet FOLLOW_PRINTF_in_imprimir332 = new BitSet(new long[]{0x0000001000000000L});
    public static final BitSet FOLLOW_PARENTESIS_A_in_imprimir334 = new BitSet(new long[]{0x0000000000000080L});
    public static final BitSet FOLLOW_CADENA_in_imprimir336 = new BitSet(new long[]{0x0000002000000400L});
    public static final BitSet FOLLOW_COMA_in_imprimir339 = new BitSet(new long[]{0x0000000000400000L});
    public static final BitSet FOLLOW_IDENT_in_imprimir341 = new BitSet(new long[]{0x0000002000000400L});
    public static final BitSet FOLLOW_PARENTESIS_C_in_imprimir345 = new BitSet(new long[]{0x0000008000000000L});
    public static final BitSet FOLLOW_PUNTO_COMA_in_imprimir347 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_BREAK_in_salir_bucle353 = new BitSet(new long[]{0x0000008000000000L});
    public static final BitSet FOLLOW_PUNTO_COMA_in_salir_bucle355 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IDENT_in_llamada_funcion361 = new BitSet(new long[]{0x0000001000000000L});
    public static final BitSet FOLLOW_PARENTESIS_A_in_llamada_funcion363 = new BitSet(new long[]{0x0000042200400080L});
    public static final BitSet FOLLOW_parametro_in_llamada_funcion366 = new BitSet(new long[]{0x0000002000000400L});
    public static final BitSet FOLLOW_COMA_in_llamada_funcion369 = new BitSet(new long[]{0x0000040200400080L});
    public static final BitSet FOLLOW_parametro_in_llamada_funcion371 = new BitSet(new long[]{0x0000002000000400L});
    public static final BitSet FOLLOW_PARENTESIS_C_in_llamada_funcion377 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IF_in_regla_if384 = new BitSet(new long[]{0x0000001100000000L});
    public static final BitSet FOLLOW_condicion_in_regla_if386 = new BitSet(new long[]{0x0000000020000000L});
    public static final BitSet FOLLOW_cuerpo_in_regla_if388 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_comparacion_in_condicional_aritm395 = new BitSet(new long[]{0x0000000008000000L});
    public static final BitSet FOLLOW_INTERROGANTE_in_condicional_aritm397 = new BitSet(new long[]{0x0000000200400100L});
    public static final BitSet FOLLOW_expr_in_condicional_aritm399 = new BitSet(new long[]{0x0000000000080000L});
    public static final BitSet FOLLOW_DOS_PUNTOS_in_condicional_aritm401 = new BitSet(new long[]{0x0000000200400100L});
    public static final BitSet FOLLOW_expr_in_condicional_aritm403 = new BitSet(new long[]{0x0000008000000000L});
    public static final BitSet FOLLOW_PUNTO_COMA_in_condicional_aritm405 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_FOR_in_regla_for412 = new BitSet(new long[]{0x0000001000000000L});
    public static final BitSet FOLLOW_PARENTESIS_A_in_regla_for414 = new BitSet(new long[]{0x0000008004400000L});
    public static final BitSet FOLLOW_iteracion_for_in_regla_for416 = new BitSet(new long[]{0x0000002000000000L});
    public static final BitSet FOLLOW_PARENTESIS_C_in_regla_for418 = new BitSet(new long[]{0x0000000020000000L});
    public static final BitSet FOLLOW_cuerpo_in_regla_for420 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_INT_in_iteracion_for428 = new BitSet(new long[]{0x0000000000400000L});
    public static final BitSet FOLLOW_asignacion_in_iteracion_for431 = new BitSet(new long[]{0x0000008200400100L});
    public static final BitSet FOLLOW_PUNTO_COMA_in_iteracion_for434 = new BitSet(new long[]{0x0000008200400100L});
    public static final BitSet FOLLOW_comparacion_in_iteracion_for437 = new BitSet(new long[]{0x0000008000000000L});
    public static final BitSet FOLLOW_PUNTO_COMA_in_iteracion_for440 = new BitSet(new long[]{0x0000001000400002L});
    public static final BitSet FOLLOW_incremento_in_iteracion_for443 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_decremento_in_iteracion_for445 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_PARENTESIS_A_in_incremento454 = new BitSet(new long[]{0x0000000000400000L});
    public static final BitSet FOLLOW_IDENT_in_incremento457 = new BitSet(new long[]{0x0000002002000000L});
    public static final BitSet FOLLOW_PARENTESIS_C_in_incremento459 = new BitSet(new long[]{0x0000000002000000L});
    public static final BitSet FOLLOW_INCREMENTO_in_incremento462 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_PARENTESIS_A_in_decremento468 = new BitSet(new long[]{0x0000000000400000L});
    public static final BitSet FOLLOW_IDENT_in_decremento471 = new BitSet(new long[]{0x0000002000020000L});
    public static final BitSet FOLLOW_PARENTESIS_C_in_decremento473 = new BitSet(new long[]{0x0000000000020000L});
    public static final BitSet FOLLOW_DECREMENTO_in_decremento476 = new BitSet(new long[]{0x0000000000000002L});

}